package com.atguigu.tingshu.album.service.impl;

import com.atguigu.tingshu.album.mapper.AlbumAttributeValueMapper;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.common.constant.KafkaConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.service.KafkaService;
import com.atguigu.tingshu.common.util.AuthContextHolder;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.query.album.AlbumInfoQuery;
import com.atguigu.tingshu.vo.album.AlbumAttributeValueVo;
import com.atguigu.tingshu.vo.album.AlbumInfoVo;
import com.atguigu.tingshu.vo.album.AlbumListVo;
import com.atguigu.tingshu.vo.album.AlbumStatVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Slf4j
@Service
@SuppressWarnings({"unchecked", "rawtypes"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

	@Autowired
	private AlbumInfoMapper albumInfoMapper;
	@Resource
	private AlbumAttributeValueMapper albumAttributeValueMapper;
	@Resource
	private AlbumStatMapper albumStatMapper;
	@Resource
	private KafkaService kafkaService;



	@Transactional
	@Override
	public void saveAlbumInfo(AlbumInfo albumInfo) {
		Long userId = AuthContextHolder.getUserId();
		albumInfo.setUserId(userId==null?1:userId);
		albumInfo.setIncludeTrackCount(0);
		albumInfo.setIsFinished(null);
		albumInfo.setQualityScore(null);
		if(SystemConstant.ALBUM_PAY_TYPE_FREE.equals(albumInfo.getPayType())){
			albumInfo.setTracksForFree(5);
		}
		albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
		this.save(albumInfo);

		Long albumId = albumInfo.getId();
		List<AlbumAttributeValue> albumAttributeValueVoList = albumInfo.getAlbumAttributeValueVoList();
		if (!CollectionUtils.isEmpty(albumAttributeValueVoList)){
			 albumAttributeValueVoList.forEach(albumAttributeValue -> {
				 albumAttributeValue.setAlbumId(albumId);
				 albumAttributeValueMapper.insert(albumAttributeValue);
			 });
		}

		insertAlbumStat(albumId,SystemConstant.ALBUM_STAT_PLAY);
		insertAlbumStat(albumId,SystemConstant.ALBUM_STAT_SUBSCRIBE);
		insertAlbumStat(albumId,SystemConstant.ALBUM_STAT_BROWSE);
		insertAlbumStat(albumId,SystemConstant.ALBUM_STAT_COMMENT);
		if ("1".equals(albumInfo.getIsOpen())){
			kafkaService.sendMsg(KafkaConstant.QUEUE_ALBUM_UPPER,albumId.toString());
		}

	}

	@Override
	public Page<AlbumListVo> findUserAlbumPage(Integer page, Integer limit, AlbumInfoQuery albumInfoQuery) {
		Long userId = AuthContextHolder.getUserId();
		albumInfoQuery.setUserId(userId==null?1:userId);
		return albumInfoMapper.findUserAlbumPage(new Page<AlbumListVo>(page,limit),albumInfoQuery);
	}

	@Override
	//用AlbumInfoVo接受没有userId，前端以为是新增
	public AlbumInfo getAlbumInfo(Long albumId) {
		AlbumInfo albumInfo = this.getById(albumId);
		List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueMapper.selectList(new LambdaQueryWrapper<AlbumAttributeValue>()
				.eq(AlbumAttributeValue::getAlbumId, albumId));
		if (!CollectionUtils.isEmpty(albumAttributeValueList)){
			albumInfo.setAlbumAttributeValueVoList(albumAttributeValueList);
		}
		return albumInfo;
	}

	@Transactional
	@Override
	public void updateAlbumInfo(Long albumId,AlbumInfoVo albumInfoVo) {

		AlbumInfo albumInfo = this.getById(albumId);
		BeanUtils.copyProperties(albumInfoVo,albumInfo);
		Long userId = AuthContextHolder.getUserId();
		albumInfo.setUserId(userId== null ? 1 : userId);
		albumInfo.setId(albumId);
		this.updateById(albumInfo);
		List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
		if (CollectionUtils.isEmpty(albumAttributeValueVoList)){
			return;
		}
		albumAttributeValueMapper.delete(new LambdaQueryWrapper<AlbumAttributeValue>()
				.eq(AlbumAttributeValue::getAlbumId, albumId));
		albumAttributeValueVoList.forEach(albumAttributeValueVo -> {
			AlbumAttributeValue albumAttributeValue = new AlbumAttributeValue();
			BeanUtils.copyProperties(albumAttributeValueVo,albumAttributeValue);
			albumAttributeValue.setAlbumId(albumId);
			albumAttributeValueMapper.insert(albumAttributeValue);
		});
		if ("1".equals(albumInfoVo.getIsOpen())){
			kafkaService.sendMsg(KafkaConstant.QUEUE_ALBUM_UPPER,albumId.toString());
		}
	}

	@Transactional
	@Override
	public void removeAlbumInfo(Long albumId) {
		this.removeById(albumId);
		albumAttributeValueMapper.delete(new LambdaUpdateWrapper<AlbumAttributeValue>()
				.eq(AlbumAttributeValue::getAlbumId, albumId));
		albumStatMapper.delete(new LambdaUpdateWrapper<AlbumStat>()
				.eq(AlbumStat::getAlbumId, albumId));
		kafkaService.sendMsg(KafkaConstant.QUEUE_ALBUM_LOWER,albumId.toString());
	}

	@Override
	public List<AlbumInfo> findUserAllAlbumList() {
		Long userId = AuthContextHolder.getUserId();
		userId=userId==null?1:userId;
		List<AlbumInfo> albumInfoList = this.list(new LambdaQueryWrapper<AlbumInfo>().eq(AlbumInfo::getUserId, userId)
				.select(AlbumInfo::getId, AlbumInfo::getAlbumTitle)
				.orderByDesc(AlbumInfo::getId));
		return albumInfoList;
	}

	private void insertAlbumStat(Long albumId,String statType) {
		AlbumStat albumStat = new AlbumStat();
		albumStat.setStatType(statType);
		albumStat.setStatNum(0);
		albumStat.setAlbumId(albumId);
		albumStatMapper.insert(albumStat);
	}

	@Override
	public Page<AlbumInfo> findAllAlbumPage(Integer page, Integer limit) {
		return this.page(new Page<>(page,limit));
	}

	@Override
	public List<AlbumAttributeValue> getAlbumAttributeById(Long albumId) {
		return albumAttributeValueMapper.selectList(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId,albumId));

	}

	@Override
	public AlbumStatVo getAlbumStatByAlbumId(Long albumId) {
		return albumInfoMapper.getAlbumStatByAlbumId(albumId);
	}

}
